GooseMemoryMap Class Reference

The class describing both local and seasonal goose memories and cognition. More...

#include <GooseMemoryMap.h>

Public Member Functions
	GooseMemoryMap (Goose_Base *a_owner)
	Constructor. More...
	~GooseMemoryMap ()
	Destructor. More...
void	MemAdd (GooseMemoryLocation a_gml)
	Add a new memory location. More...
bool	MemDel (int a_polyid)
	Delete a memory location. More...
bool	ChangeAddFoodRes (int a_polyid, double a_foodres)
	Add to food at a memory location. More...
bool	ChangeAddThreat (int a_polyid, double a_threat)
	Add to threat at a memory location. More...
bool	ChangeMultFoodRes (int a_polyid, double a_foodres)
	Multiply food at a memory location. More...
bool	ChangeSetFoodRes (int a_polyid, double a_grain, double a_maize, double a_grazing)
	Set food at a memory location. More...
bool	ChangeMultThreat (int a_polyid, double a_threat)
	Multiply threat at a memory location. More...
double	GetFoodRes (int a_polyid)
	Get the food resource at location. More...
double	GetThreat (int a_polyid)
	Get the threat level at location. More...
GooseMemoryLocation	GetBestFeedingScore ()
	Find the current best feeding location. More...
double	CalcScore (int a_dist, double a_foodresource, double a_threat)
	Inline function to calulate overall score for a distance, resource and threat. More...
bool	IsKnownArea (int a_polyid)
	Check if this location is known. More...
void	DecayAllMemory ()
	Decay all memory. More...
double	GetTotalThreats (void)
	Get total of threat currently remembered. More...
void	ClearAllMemory (void)
	Remove all memory. More...

Protected Member Functions
void	GooseMemoryError (std::string a_str, int a_value)
	Error message functionality. More...

Protected Attributes
Goose_Base *	m_myOwner
	pointer to the owner More...
double	m_threatdecayrate
	The decay rate per day for threats. More...
int	m_expectedforagingtime
	the time in minutes a goose expects to be able to forage when evaluating cost benefit of flying to a location. More...
std::vector< GooseMemoryLocation >	m_memorylocations
	The list of memory locations. More...

Detailed Description

The class describing both local and seasonal goose memories and cognition.

Constructor & Destructor Documentation

GooseMemoryMap()

GooseMemoryMap::GooseMemoryMap

(

Goose_Base *

a_owner

)

Constructor.

{
    m_myOwner = a_owner;
    m_threatdecayrate = cfg_goose_mem_threatdecayrate.value();
    m_expectedforagingtime = cfg_goose_mem_expectedforagingtime.value();
    GooseMemoryLocation aloc;
    aloc.m_infinitememorystop = cfg_goose_mem_minmemoryvalue.value(); // Set the static variable
    //m_memorylocations.reserve(200); // there are usually 200-300 memories, reserving this in advance does not hurt, and speeds the process when new elements are added (a bit).
}

References cfg_goose_mem_expectedforagingtime, cfg_goose_mem_minmemoryvalue, cfg_goose_mem_threatdecayrate, GooseMemoryLocation::m_infinitememorystop, CfgInt::value(), and CfgFloat::value().

~GooseMemoryMap()

GooseMemoryMap::~GooseMemoryMap ( )

inline

Destructor.

                      { 
        m_memorylocations.erase(m_memorylocations.begin(),m_memorylocations.end());
    }

References m_memorylocations.

Member Function Documentation

CalcScore()

double GooseMemoryMap::CalcScore	(	int	a_dist,
		double	a_foodresource,
		double	a_threat
	)

Inline function to calulate overall score for a distance, resource and threat.

Parameters

[in]	a_dist	The distance to the location
[in]	a_foodresource	The foodresource at the location
[in]	a_threat	A measure of the strength of threat memory.

Returns

the memory score calculation result

{
        double cost = a_dist * m_myOwner->GetFlightCost();
        double score = (a_foodresource * m_expectedforagingtime) - cost;
        score = score * (1 - a_threat);
        return score;
}

Referenced by Goose_Base::EvaluateForageToHopLoc(), Goose_Base::On_Bang(), and Goose_Base::st_ChooseForageLocation().

ChangeAddFoodRes()

bool GooseMemoryMap::ChangeAddFoodRes	(	int	a_polyid,
		double	a_foodres
	)

Add to food at a memory location.

Parameters

a_polyid	[in] A unique polygon reference to a goose memory location.
a_foodres	[in] A measure of the strength of food resource memory.

Returns

success

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find one bigger and add the food resource to be added

{
    std::vector<GooseMemoryLocation>::iterator it;
    for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
    {
        if (it->m_polygonid == a_polyid)
        {
            it->m_foodresource += a_foodres;
            return true; // all good
        }
    }
    return false; // entry not found
}

ChangeAddThreat()

bool GooseMemoryMap::ChangeAddThreat	(	int	a_polyid,
		double	a_threat
	)

Add to threat at a memory location.

Parameters

a_polyid	[in] A unique polygon reference to a goose memory location.
a_threat	[in] A measure of the strength of threat memory.

Returns

success

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find one bigger and add the threat to be added

{
    std::vector<GooseMemoryLocation>::iterator it;
    for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
    {
        if (it->m_polygonid == a_polyid)
        {
            it->m_threat += a_threat;
            return true; // all good
        }
    }
    return false; // entry not found
}

Referenced by Goose_Base::On_Bang().

ChangeMultFoodRes()

bool GooseMemoryMap::ChangeMultFoodRes	(	int	a_polyid,
		double	a_foodres
	)

Multiply food at a memory location.

Parameters

a_polyid	[in] A unique polygon reference to a goose memory location.
a_foodres	[in] A measure of the strength of food resource memory.

Returns

success

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find one bigger and multiply by the value passed

{
    std::vector<GooseMemoryLocation>::iterator it;
    for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
    {
        if (it->m_polygonid == a_polyid)
        {
            it->m_foodresource *= a_foodres;
            return true; // all good
        }
    }
    return false; // entry not found
}

ChangeMultThreat()

bool GooseMemoryMap::ChangeMultThreat	(	int	a_polyid,
		double	a_threat
	)

Multiply threat at a memory location.

Parameters

a_polyid	[in] A unique polygon reference to a goose memory location.
a_threat	[in] The memory of a threat at this location

Returns

success

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find one bigger and multiply by the value passed

{
    std::vector<GooseMemoryLocation>::iterator it;
    for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
    {
        if (it->m_polygonid == a_polyid)
        {
            it->m_threat *= a_threat;
            return true; // all good
        }
    }
    return false; // entry not found
}

ChangeSetFoodRes()

bool GooseMemoryMap::ChangeSetFoodRes	(	int	a_polyid,
		double	a_grain,
		double	a_maize,
		double	a_grazing
	)

Set food at a memory location.

Parameters

a_polyid	[in] A unique polygon reference to a goose memory location.
a_grain	[in] The grain food resource.
a_maize	[in] The maize food resource.
a_grazing	[in] The grazing food resource.

Returns

success

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find our polygon.

Todo:

Speed-up Identified as the program bottleneck. The problem is that in most cases this is called we run all the way to the end of the vector and don't find our polygon.

{
    std::vector<GooseMemoryLocation>::iterator it;
    for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
    {
        if (it->m_polygonid == a_polyid)
        {
            it->m_grain = a_grain;
            it->m_maize = a_maize;
            it->m_grazing = a_grazing;
            it->m_foodresource = m_myOwner->GetMaxIntakeRate(a_grain, a_maize, a_grazing);
            APoint roost = m_myOwner->GetRoost();
            int dist = g_AlmassMathFuncs.CalcDistPythagorasApprox( roost.m_x, roost.m_y, it->m_x, it->m_y );
            it->m_score = CalcScore(dist, it->m_foodresource, it->m_threat);
            return true; // all good
        }
    }
    return false; // entry not found
}

References ALMaSS_MathFuncs::CalcDistPythagorasApprox(), g_AlmassMathFuncs, APoint::m_x, and APoint::m_y.

Referenced by Goose_Base::st_ChooseForageLocation(), and Goose_Base::st_Forage().

ClearAllMemory()

void GooseMemoryMap::ClearAllMemory

(

void

)

Remove all memory.

Returns

None

{
    m_memorylocations.erase(m_memorylocations.begin(), m_memorylocations.end());
}

DecayAllMemory()

void GooseMemoryMap::DecayAllMemory

(

void

)

Decay all memory.

1 - Loop through all locations 2 - Decay the memory 3 - Update the memory score 4 - Remove any memories that are old

{
    vector<GooseMemoryLocation>::iterator it;
    for (it = m_memorylocations.begin(); it != m_memorylocations.end(); it++)
    {
        // 2 - Decay and age the memory 
        it->m_threat *= m_threatdecayrate;
        it->m_age++;
        // 3. Update the memory score
        int rx = m_myOwner->GetRoost().m_x;
        int ry = m_myOwner->GetRoost().m_y;
        int dist = g_AlmassMathFuncs.CalcDistPythagorasApprox( rx, ry, it->m_x, it->m_y );
        double flightcost = m_myOwner->GetFlightCost();
        it->CalcScore(dist, flightcost, m_expectedforagingtime);
    }
    // 4. Remove memories too old
    m_memorylocations.erase(remove_if(m_memorylocations.begin(), m_memorylocations.end(), IsMarkedToDelete), m_memorylocations.end());
}

References ALMaSS_MathFuncs::CalcDistPythagorasApprox(), g_AlmassMathFuncs, and IsMarkedToDelete().

Referenced by Goose_Base::StartDay().

GetBestFeedingScore()

GooseMemoryLocation GooseMemoryMap::GetBestFeedingScore

(

)

Find the current best feeding location.

Returns

Best food resource memory in memory after taking threats and distance from roost into account

0 - If there are no memories return an impossible score to trigger explore 1 - Loop through all locations. 2 - Keep track of the best score. 3 - We need a way out if nothing is at all suitable, so if score is too small return a dummy location with a big negative score. 4 - Return the best scoring location if we have one.

{
    double score = -9999.0;
    if (m_memorylocations.size()<1)
    {
        GooseMemoryLocation gml;
        gml.m_score = score;
        return gml;
    }
 
    std::vector<GooseMemoryLocation>::iterator ci, ci_best;
    for (ci = m_memorylocations.begin(); ci != m_memorylocations.end(); ++ci)
    {
        if (ci->m_score>score)
        {
            ci_best = ci;
            score = ci->m_score;
        }
    }
    if (score < 1)
    {
        GooseMemoryLocation gml;
        gml.m_score = -9999;
        return gml;
    }
    return *(ci_best);
}

References GooseMemoryLocation::m_score.

Referenced by Goose_Base::st_ChooseForageLocation().

GetFoodRes()

double GooseMemoryMap::GetFoodRes

(

int

a_polyid

)

Get the food resource at location.

Parameters

a_polyid

[in] A unique polygon reference to a goose memory location.

Returns

Food resource memory at a_polyid

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list.

{
    std::vector<GooseMemoryLocation>::const_iterator ci;
    for (ci = m_memorylocations.begin(); ci != m_memorylocations.end(); ++ci)
    {
        if (ci->m_polygonid == a_polyid) return ci->m_foodresource;
    }
    GooseMemoryError("Polygonid not found", a_polyid);
    return 0; // compiler happiness
}

GetThreat()

double GooseMemoryMap::GetThreat

(

int

a_polyid

)

Get the threat level at location.

Parameters

a_polyid

[in] A unique polygon reference to a goose memory location.

Returns

Threat memory at a_polyid

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list.

{
    std::vector<GooseMemoryLocation>::const_iterator ci;
    for (ci = m_memorylocations.begin(); ci != m_memorylocations.end(); ++ci)
    {
        if (ci->m_polygonid == a_polyid) return ci->m_threat;
    }
    GooseMemoryError("Polygonid not found", a_polyid);
    return 0; // compiler happiness
}

GetTotalThreats()

double GooseMemoryMap::GetTotalThreats

(

void

)

Get total of threat currently remembered.

Returns

The sum of total threats remembered

1 - Loop through all locations.

2 - Sum the threats and return this.

{
    double theThreat = 0.0;
    std::vector<GooseMemoryLocation>::iterator it;
    for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
    {
        theThreat += it->m_threat;
    }
    return theThreat;
}

GooseMemoryError()

void GooseMemoryMap::GooseMemoryError ( std::string  a_str, int  a_value  )

protected

Error message functionality.

Parameters

[in]	a_str	A string to send as output
[in]	a_value	A value to send as output

Opens a file called GooseMemoryMapError.txt and prints an error message before dumping the contents of the current memory. The program then closes.

{
    std::ofstream ofile("GooseMemoryMapError.txt", std::ios::app | std::ios::out);
    ofile << a_str << ':' << a_value << std::endl;
    // Dumping goose memory
    std::vector<GooseMemoryLocation>::iterator ci;
    ofile << "polygonid" << '\t' << "m_x" << '\t' << "m_y" << '\t' << "foodresource" << '\t' << "threat" << std::endl;
    for (ci = m_memorylocations.begin(); ci != m_memorylocations.end(); ++ci)
    {
        ofile << ci->m_polygonid << '\t' << ci->m_x << '\t' << ci->m_y << '\t' << ci->m_foodresource << '\t' << ci->m_threat << std::endl;
    }
    ofile.close();
    exit(9);
}

IsKnownArea()

bool GooseMemoryMap::IsKnownArea

(

int

a_polyid

)

Check if this location is known.

Parameters

a_polyid

[in] A unique polygon reference to a goose memory location.

Returns

true if we have this polygon otherwise false.

Loop through all locations and see if we have this polygon

If we have it, return true, otherwise return false.

{
    std::vector<GooseMemoryLocation>::iterator it;
    for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
    {
        if (it->m_polygonid == a_polyid) return true;
    }
    return false;
}

Referenced by Goose_Base::st_ChooseForageLocation().

MemAdd()

void GooseMemoryMap::MemAdd

(

GooseMemoryLocation

a_gml

)

Add a new memory location.

Parameters

a_gml

[in] A goose memory location to add to the memory list.

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find one bigger and insert before it.
However, perhaps we have been here before, so just in case make a test and quitely update the memory if we find this polygon id in the list.
If no polygon ids are bigger or equal to ours then we need to add ours to the end of the list.

{
    if (m_memorylocations.size() == 0)
    {
        m_memorylocations.push_back(a_gml);
        return;
    }
    int polyid = a_gml.m_polygonid;
    std::vector<GooseMemoryLocation>::iterator ci;
    for (ci = m_memorylocations.begin(); ci != m_memorylocations.end(); ++ci)
    {
        if (ci->m_polygonid>polyid)
        {
            m_memorylocations.insert(ci, a_gml);
            return;
        }
        if (ci->m_polygonid == polyid)
        {
            // We have been here before so update memory
            ci->m_grain = a_gml.m_grain;
            ci->m_maize = a_gml.m_maize;
            ci->m_grazing = a_gml.m_grazing;
            ci->m_foodresource = a_gml.m_foodresource;
            return;
        }
        // the only possibility left is that polyid is > than any on our list, so push it to the end
    }
    m_memorylocations.push_back(a_gml);
}

References GooseMemoryLocation::m_foodresource, GooseMemoryLocation::m_grain, GooseMemoryLocation::m_grazing, GooseMemoryLocation::m_maize, and GooseMemoryLocation::m_polygonid.

Referenced by Goose_Base::EvaluateForageToHopLoc(), Goose_Base::On_Bang(), and Goose_Base::st_ChooseForageLocation().

MemDel()

bool GooseMemoryMap::MemDel

(

int

a_polyid

)

Delete a memory location.

Parameters

a_polyid

[in] A unique polygon reference to a goose memory location.

Returns

success

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find the right one and remove it

{
    for (std::vector<GooseMemoryLocation>::iterator ci = m_memorylocations.begin(); ci != m_memorylocations.end(); ++ci)
    {
        if (ci->m_polygonid == a_polyid)
        {
            m_memorylocations.erase(ci);
            return true;
        }
    }
    return false;
}

Referenced by Goose_Base::st_Forage().

Member Data Documentation

m_expectedforagingtime

int GooseMemoryMap::m_expectedforagingtime

protected

the time in minutes a goose expects to be able to forage when evaluating cost benefit of flying to a location.

m_memorylocations

std::vector<GooseMemoryLocation> GooseMemoryMap::m_memorylocations

protected

The list of memory locations.

Referenced by ~GooseMemoryMap().

m_myOwner

Goose_Base* GooseMemoryMap::m_myOwner

protected

pointer to the owner

m_threatdecayrate

double GooseMemoryMap::m_threatdecayrate

protected

The decay rate per day for threats.

---

The documentation for this class was generated from the following files:

• /builds/a1mass/almass_stable_oddox/GooseManagement/GooseMemoryMap.h
• /builds/a1mass/almass_stable_oddox/GooseManagement/GooseMemoryMap.cpp